package com.ruoyi.tzai.service.ai;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.tzai.domain.AIModelConfig;
import com.ruoyi.tzai.domain.ApiKeyPool;
import com.ruoyi.tzai.service.IAIModelConfigService;
import com.ruoyi.tzai.service.IApiKeyPoolService;
import com.ruoyi.tzai.service.ai.impl.OpenAIServiceImpl;
import com.ruoyi.tzai.service.ai.impl.AliyunAIServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * AI服务工厂
 * 根据数据库配置动态创建AI服务实例
 * 
 * @author tzai
 * @date 2025-10-27
 */
@Component
public class AIServiceFactory 
{
    private static final Logger log = LoggerFactory.getLogger(AIServiceFactory.class);

    @Autowired
    private IAIModelConfigService aiModelConfigService;

    @Autowired
    private IApiKeyPoolService apiKeyPoolService;

    /** 服务实例缓存（注意：不缓存带Key的实例，因为Key是动态的） */
    private final Map<Long, IAIService> serviceCache = new ConcurrentHashMap<>();

    /**
     * 获取默认AI服务
     * 
     * @return AI服务实例
     */
    public IAIService getDefaultService() {
        AIModelConfig config = aiModelConfigService.selectDefaultAIModelConfig();
        if (config == null) {
            log.error("未找到默认AI模型配置");
            return null;
        }
        return getService(config.getModelId());
    }

    /**
     * 根据模型ID获取AI服务（自动从Key池获取第一个可用Key）
     * 注意：此方法适用于简单场景，不支持Key的释放管理
     * 
     * @param modelId 模型ID
     * @return AI服务实例
     */
    public IAIService getService(Long modelId) {
        // 从数据库加载配置
        AIModelConfig config = aiModelConfigService.selectAIModelConfigByModelId(modelId);
        if (config == null) {
            log.error("未找到AI模型配置: {}", modelId);
            return null;
        }

        // 从Key池获取一个可用的Key
        List<ApiKeyPool> keys = apiKeyPoolService.acquireKeys("ai_model", modelId, 1);
        if (keys == null || keys.isEmpty()) {
            log.error("未找到可用的API Key for model: {}", modelId);
            return null;
        }

        ApiKeyPool keyPool = keys.get(0);
        IAIService service = createServiceWithKey(config, keyPool.getApiKey());
        
        // 注意：这里获取的Key不会自动释放，调用者需要手动管理
        // 建议使用任务队列系统进行复杂的Key管理
        
        return service;
    }

    /**
     * 使用指定的API Key创建AI服务
     * 
     * @param config AI模型配置
     * @param apiKey API Key
     * @return AI服务实例
     */
    public IAIService createServiceWithKey(AIModelConfig config, String apiKey) {
        try {
            String provider = config.getProvider();
            
            if ("openai".equalsIgnoreCase(provider)) {
                return createOpenAIService(config, apiKey);
            } else if ("deepseek".equalsIgnoreCase(provider)) {
                return createDeepSeekService(config, apiKey);
            } else if ("claude".equalsIgnoreCase(provider)) {
                // TODO: 实现Claude服务
                log.warn("Claude服务暂未实现");
                return null;
            } else if ("aliyun".equalsIgnoreCase(provider)) {
                return createAliyunService(config, apiKey);
            } else {
                log.error("不支持的AI提供商: {}", provider);
                return null;
            }
        } catch (Exception e) {
            log.error("创建AI服务失败", e);
            return null;
        }
    }

    /**
     * 创建OpenAI服务
     */
    private IAIService createOpenAIService(AIModelConfig config, String apiKey) {
        try {
            OpenAIServiceImpl service = new OpenAIServiceImpl();
            
            // 设置API Key（从Key池获取）
            if (apiKey != null && !apiKey.isEmpty()) {
                service.setApiKey(apiKey);
            }
            
            // 设置API Endpoint
            if (config.getApiEndpoint() != null && !config.getApiEndpoint().isEmpty()) {
                service.setApiEndpoint(config.getApiEndpoint());
            }
            
            // 设置模型参数（JSON格式）
            if (config.getModelParams() != null && !config.getModelParams().isEmpty()) {
                try {
                    JSONObject params = JSON.parseObject(config.getModelParams());
                    if (params.containsKey("model")) {
                        service.setModel(params.getString("model"));
                    }
                } catch (Exception e) {
                    log.warn("解析模型参数失败: {}", e.getMessage());
                }
            }

            log.info("创建OpenAI服务成功: {}", config.getModelName());
            return service;
        } catch (Exception e) {
            log.error("创建OpenAI服务失败", e);
            return null;
        }
    }

    /**
     * 创建DeepSeek服务（兼容OpenAI API）
     */
    private IAIService createDeepSeekService(AIModelConfig config, String apiKey) {
        try {
            OpenAIServiceImpl service = new OpenAIServiceImpl();
            
            // 设置API Key（从Key池获取）
            if (apiKey != null && !apiKey.isEmpty()) {
                service.setApiKey(apiKey);
            }
            
            // 设置API Endpoint（DeepSeek API地址）
            if (config.getApiEndpoint() != null && !config.getApiEndpoint().isEmpty()) {
                service.setApiEndpoint(config.getApiEndpoint());
            }
            
            // 设置模型参数（JSON格式）
            if (config.getModelParams() != null && !config.getModelParams().isEmpty()) {
                try {
                    JSONObject params = JSON.parseObject(config.getModelParams());
                    if (params.containsKey("model")) {
                        service.setModel(params.getString("model"));
                    }
                } catch (Exception e) {
                    log.warn("解析模型参数失败: {}", e.getMessage());
                }
            }

            log.info("创建DeepSeek服务成功: {}", config.getModelName());
            return service;
        } catch (Exception e) {
            log.error("创建DeepSeek服务失败", e);
            return null;
        }
    }

    /**
     * 创建阿里云通义千问服务
     */
    private IAIService createAliyunService(AIModelConfig config, String apiKey) {
        try {
            AliyunAIServiceImpl service = new AliyunAIServiceImpl();
            
            // 设置API Key（从Key池获取）
            if (apiKey != null && !apiKey.isEmpty()) {
                service.setApiKey(apiKey);
            }
            
            // 设置API Endpoint
            if (config.getApiEndpoint() != null && !config.getApiEndpoint().isEmpty()) {
                service.setApiEndpoint(config.getApiEndpoint());
            }
            
            // 设置模型代码（API使用的模型标识，如 qwen-max）
            if (config.getModelCode() != null && !config.getModelCode().isEmpty()) {
                service.setModelName(config.getModelCode());
            } else {
                // 兼容旧配置：如果没有 modelCode，使用默认值
                service.setModelName("qwen-max");
            }

            log.info("创建阿里云通义千问服务成功: {} ({})", config.getModelName(), config.getModelCode());
            return service;
        } catch (Exception e) {
            log.error("创建阿里云通义千问服务失败", e);
            return null;
        }
    }

    /**
     * 清除缓存
     * 
     * @param modelId 模型ID
     */
    public void clearCache(Long modelId) {
        serviceCache.remove(modelId);
        log.info("清除AI服务缓存: {}", modelId);
    }

    /**
     * 清除所有缓存
     */
    public void clearAllCache() {
        serviceCache.clear();
        log.info("清除所有AI服务缓存");
    }
}

